home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / share / python / pyversions.py < prev   
Encoding:
Python Source  |  2012-05-04  |  14.5 KB  |  395 lines
  1. #! /usr/bin/python
  2.  
  3. import os, re, sys
  4. try:
  5.     SetType = set
  6. except NameError:
  7.     import sets
  8.     SetType = sets.Set
  9.     set = sets.Set
  10.  
  11. _defaults = None
  12. def read_default(name=None):
  13.     global _defaults
  14.     from ConfigParser import SafeConfigParser, NoOptionError
  15.     if not _defaults:
  16.         if os.path.exists('/usr/share/python/debian_defaults'):
  17.             config = SafeConfigParser()
  18.             try:
  19.                 config.readfp(file('/usr/share/python/debian_defaults'))
  20.             except IOError, msg:
  21.                 print msg
  22.                 sys.exit(1)
  23.             _defaults = config
  24.     if _defaults and name:
  25.         try:
  26.             value = _defaults.get('DEFAULT', name)
  27.         except NoOptionError:
  28.             raise ValueError
  29.         return value
  30.     return None
  31.  
  32. def parse_versions(vstring, add_exact=False):
  33.     import operator
  34.     operators = { None: operator.eq, '=': operator.eq,
  35.                   '>=': operator.ge, '<=': operator.le,
  36.                   '<<': operator.lt
  37.                   }
  38.     vinfo = {}
  39.     exact_versions = set([])
  40.     version_range = set(supported_versions(version_only=True)
  41.                         + old_versions(version_only=True))
  42.     relop_seen = False
  43.     for field in vstring.split(','):
  44.         field = field.strip()
  45.         if field == 'all':
  46.             vinfo['all'] = 'all'
  47.             continue
  48.         if field in ('current', 'current_ext'):
  49.             vinfo['current'] = field
  50.             continue
  51.         vinfo.setdefault('versions', set())
  52.         ve = re.compile('(>=|<=|<<|=)? *(\d\.\d)$')
  53.         m = ve.match(field)
  54.         try:
  55.             if not m:
  56.                 raise ValueError('error parsing Python-Version attribute')
  57.             op, v = m.group(1), m.group(2)
  58.             vmaj, vmin = v.split('.')
  59.             # Don't silently ignore Python 3 versions for Squeeze.
  60.             #if int(vmaj) > 2:
  61.             #    continue
  62.             if op in (None, '='):
  63.                 exact_versions.add(v)
  64.             else:
  65.                 relop_seen = True
  66.                 filtop = operators[op]
  67.                 version_range = [av for av in version_range if filtop(av ,v)]
  68.         except Exception:
  69.             raise ValueError, 'error parsing Python-Version attribute'
  70.     if add_exact:
  71.         if exact_versions:
  72.             vinfo['vexact'] = exact_versions
  73.         if 'versions' in vinfo:
  74.             if relop_seen:
  75.                 vinfo['versions'] = set(version_range)
  76.             else:
  77.                 del vinfo['versions']
  78.     else:
  79.         if 'versions' in vinfo:
  80.             vinfo['versions'] = exact_versions
  81.             if relop_seen:
  82.                 vinfo['versions'] = exact_versions.union(version_range)
  83.     return vinfo
  84.  
  85. _old_versions = None
  86. def old_versions(version_only=False):
  87.     global _old_versions
  88.     if not _old_versions:
  89.         try:
  90.             value = read_default('old-versions')
  91.             _old_versions = [s.strip() for s in value.split(',')]
  92.         except ValueError:
  93.             _old_versions = []
  94.     if version_only:
  95.         return [v[6:] for v in _old_versions]
  96.     else:
  97.         return _old_versions
  98.  
  99. _unsupported_versions = None
  100. def unsupported_versions(version_only=False):
  101.     global _unsupported_versions
  102.     if not _unsupported_versions:
  103.         try:
  104.             value = read_default('unsupported-versions')
  105.             _unsupported_versions = [s.strip() for s in value.split(',')]
  106.         except ValueError:
  107.             _unsupported_versions = []
  108.     if version_only:
  109.         return [v[6:] for v in _unsupported_versions]
  110.     else:
  111.         return _unsupported_versions
  112.  
  113. _supported_versions = None
  114. def supported_versions(version_only=False):
  115.     global _supported_versions
  116.     if not _supported_versions:
  117.         try:
  118.             value = read_default('supported-versions')
  119.             _supported_versions = [s.strip() for s in value.split(',')]
  120.         except ValueError:
  121.             cmd = ['/usr/bin/apt-cache', '--no-all-versions',
  122.                    'show', 'python-all']
  123.             try:
  124.                 import subprocess
  125.                 p = subprocess.Popen(cmd, bufsize=1,
  126.                                      shell=False, stdout=subprocess.PIPE)
  127.                 fd = p.stdout
  128.             except ImportError:
  129.                 fd = os.popen(' '.join(cmd))
  130.             depends = None
  131.             for line in fd:
  132.                 if line.startswith('Depends:'):
  133.                     depends = line.split(':', 1)[1].strip().split(',')
  134.             fd.close()
  135.             if depends:
  136.                 depends = [re.sub(r'\s*(\S+)[ (]?.*', r'\1', s) for s in depends]
  137.                 _supported_versions = depends
  138.             if not _supported_versions:
  139.                 # last resort: python-minimal not installed, apt-cache
  140.                 # not available, hard code the value, #394084
  141.                 _supported_versions = ['python2.5', 'python2.6']
  142.     if version_only:
  143.         return [v[6:] for v in _supported_versions]
  144.     else:
  145.         return _supported_versions
  146.  
  147. _default_version = None
  148. def default_version(version_only=False):
  149.     global _default_version
  150.     if not _default_version:
  151.         try:
  152.             _default_version = link = os.readlink('/usr/bin/python')
  153.         except OSError:
  154.             _default_version = None
  155.             try:
  156.                 cmd = ['/usr/bin/python', '-c', 'import sys; print sys.version[:3]']
  157.                 import subprocess
  158.                 p = subprocess.Popen(cmd, bufsize=1,
  159.                                      shell=False, stdout=subprocess.PIPE)
  160.                 fd = p.stdout
  161.             except ImportError:
  162.                 fd = os.popen("/usr/bin/python -c 'import sys; print sys.version[:3]'")
  163.             line = fd.readline().strip()
  164.             fd.close()
  165.             if re.match(r'\d\.\d$', line):
  166.                 _default_version = 'python' + line
  167.         # consistency check
  168.         try:
  169.             debian_default = read_default('default-version')
  170.         except ValueError:
  171.             debian_default = "python2.6"
  172.         if not _default_version in (debian_default, os.path.join('/usr/bin', debian_default)):
  173.             raise ValueError, "/usr/bin/python does not match the python default version. It must be reset to point to %s" % debian_default
  174.         _default_version = debian_default
  175.     if version_only:
  176.         return _default_version[6:]
  177.     else:
  178.         return _default_version
  179.  
  180. def requested_versions(vstring, version_only=False):
  181.     versions = None
  182.     vinfo = parse_versions(vstring, add_exact=True)
  183.     supported = supported_versions(version_only=True)
  184.     if len(vinfo) == 1:
  185.         if 'all' in vinfo:
  186.             versions = supported
  187.         elif 'current' in vinfo:
  188.             versions = [default_version(version_only=True)]
  189.         elif 'vexact' in vinfo:
  190.             versions = vinfo['vexact']
  191.         else:
  192.             versions = vinfo['versions'].intersection(supported)
  193.     elif 'all' in vinfo and 'current' in vinfo:
  194.         raise ValueError, "both `current' and `all' in version string"
  195.     elif 'all' in vinfo:
  196.         if 'versions' in vinfo:
  197.             versions = vinfo['versions'].intersection(supported)
  198.         else:
  199.             versions = set(supported)
  200.         if 'vexact' in vinfo:
  201.             versions.update(vinfo['vexact'])
  202.     elif 'current' in vinfo:
  203.         current = default_version(version_only=True)
  204.         if not current in vinfo['versions']:
  205.             raise ValueError, "`current' version not in supported versions"
  206.         versions = [current]
  207.     elif 'versions' in vinfo or 'vexact' in vinfo:
  208.         versions = set()
  209.         if 'versions' in vinfo:
  210.             versions = vinfo['versions'].intersection(supported)
  211.         if 'vexact' in vinfo:
  212.             versions.update(vinfo['vexact'])
  213.     else:
  214.         raise ValueError, 'No Python versions in version string'
  215.     if not versions:
  216.         raise ValueError('computed set of supported versions is empty')
  217.     if version_only:
  218.         return versions
  219.     else:
  220.         return ['python%s' % v for v in versions]
  221.  
  222. def installed_versions(version_only=False):
  223.     import glob
  224.     supported = supported_versions()
  225.     versions = [os.path.basename(s)
  226.                 for s in glob.glob('/usr/bin/python[0-9].[0-9]')
  227.                 if os.path.basename(s) in supported]
  228.     versions.sort()
  229.     if version_only:
  230.         return [v[6:] for v in versions]
  231.     else:
  232.         return versions
  233.  
  234. class ControlFileValueError(ValueError):
  235.     pass
  236. class MissingVersionValueError(ValueError):
  237.     pass
  238.  
  239. def extract_pyversion_attribute(fn, pkg):
  240.     """read the debian/control file, extract the X-Python-Version or
  241.     XS-Python-Version field; check that XB-Python-Version exists for the
  242.     package."""
  243.  
  244.     version = None
  245.     sversion = None
  246.     section = None
  247.     try:
  248.         fp = file(fn, 'r')
  249.     except IOError, msg:
  250.         print "Cannot open %s: %s" % (fn, msg)
  251.         sys.exit(2)
  252.     for line in fp:
  253.         line = line.strip()
  254.         if line == '':
  255.             if section == None:
  256.                 continue
  257.             if pkg == 'Source':
  258.                 break
  259.             section = None
  260.         elif line.startswith('Source:'):
  261.             section = 'Source'
  262.         elif line.startswith('Package: ' + pkg):
  263.             section = pkg
  264.         elif line.startswith('XS-Python-Version:') or line.startswith('X-Python-Version:'):
  265.             if section != 'Source':
  266.                 raise ValueError, \
  267.                       'attribute X(S)-Python-Version not in Source section'
  268.             sversion = line.split(':', 1)[1].strip()
  269.         elif line.startswith('XB-Python-Version:'):
  270.             if section == pkg:
  271.                 version = line.split(':', 1)[1].strip()
  272.     if section == None:
  273.         raise ControlFileValueError, 'not a control file'
  274.     if pkg == 'Source':
  275.         if sversion == None:
  276.             raise MissingVersionValueError, \
  277.                   'missing X(S)-Python-Version in control file'
  278.         return sversion
  279.     if version == None:
  280.         raise MissingVersionValueError, \
  281.               'missing XB-Python-Version for package `%s' % pkg
  282.     return version
  283.  
  284. # compatibility functions to parse debian/pyversions
  285.  
  286. def version_cmp(ver1,ver2):
  287.     v1=[int(i) for i in ver1.split('.')]
  288.     v2=[int(i) for i in ver2.split('.')]
  289.     return cmp(v1,v2)
  290.  
  291. def requested_versions_bis(vstring, version_only=False):
  292.     versions = []
  293.     py_supported_short = supported_versions(version_only=True)
  294.     for item in vstring.split(','):
  295.         v=item.split('-')
  296.         if len(v)>1:
  297.             if not v[0]:
  298.                 v[0] = py_supported_short[0]
  299.             if not v[1]:
  300.                 v[1] = py_supported_short[-1]
  301.             for ver in py_supported_short:
  302.                 try:
  303.                     if version_cmp(ver,v[0]) >= 0 \
  304.                            and version_cmp(ver,v[1]) <= 0:
  305.                         versions.append(ver)
  306.                 except ValueError:
  307.                     pass
  308.         else:
  309.             if v[0] in py_supported_short:
  310.                 versions.append(v[0])
  311.     versions.sort(version_cmp)
  312.     if not versions:
  313.         raise ValueError, 'empty set of versions'
  314.     if not version_only:
  315.         versions=['python'+i for i in versions]
  316.     return versions
  317.  
  318. def extract_pyversion_attribute_bis(fn):
  319.     vstring = file(fn).readline().rstrip('\n')
  320.     return vstring
  321.  
  322. def main():
  323.     from optparse import OptionParser
  324.     usage = '[-v] [-h] [-d|--default] [-s|--supported] [-i|--installed] [-r|--requested <version string>|<control file>]'
  325.     parser = OptionParser(usage=usage)
  326.     parser.add_option('-d', '--default',
  327.                       help='print the default python version',
  328.                       action='store_true', dest='default')
  329.     parser.add_option('-s', '--supported',
  330.                       help='print the supported python versions',
  331.                       action='store_true', dest='supported')
  332.     parser.add_option('-r', '--requested',
  333.                       help='print the python versions requested by a build; the argument is either the name of a control file or the value of the X(S)-Python-Version attribute',
  334.                       action='store_true', dest='requested')
  335.     parser.add_option('-i', '--installed',
  336.                       help='print the installed supported python versions',
  337.                       action='store_true', dest='installed')
  338.     parser.add_option('-v', '--version',
  339.                       help='print just the version number(s)',
  340.                       default=False, action='store_true', dest='version_only')
  341.     opts, args = parser.parse_args()
  342.     program = os.path.basename(sys.argv[0])
  343.  
  344.     if opts.default and len(args) == 0:
  345.         try:
  346.             print default_version(opts.version_only)
  347.         except ValueError, msg:
  348.             print "%s:" % program, msg
  349.             sys.exit(1)
  350.     elif opts.supported and len(args) == 0:
  351.         print ' '.join(supported_versions(opts.version_only))
  352.     elif opts.installed and len(args) == 0:
  353.         print ' '.join(installed_versions(opts.version_only))
  354.     elif opts.requested and len(args) <= 1:
  355.         if len(args) == 0:
  356.             versions = 'debian/control'
  357.         else:
  358.             versions = args[0]
  359.         try:
  360.             if os.path.isfile(versions):
  361.                 fn = versions
  362.                 try:
  363.                     vstring = extract_pyversion_attribute(fn, 'Source')
  364.                     vs = requested_versions(vstring, opts.version_only)
  365.                 except ControlFileValueError:
  366.                     sys.stderr.write("%s: not a control file: %s, " \
  367.                                      % (program, fn))
  368.                     sys.exit(1)
  369.                 except MissingVersionValueError:
  370.                     fn = os.path.join(os.path.dirname(fn), 'pyversions')
  371.                     sys.stderr.write("%s: missing X(S)-Python-Version in control file, fall back to %s\n" \
  372.                                      % (program, fn))
  373.                     try:
  374.                         vstring = extract_pyversion_attribute_bis(fn)
  375.                         vs = requested_versions_bis(vstring, opts.version_only)
  376.                     except IOError:
  377.                         sys.stderr.write("%s: missing debian/pyversions file, fall back to supported versions\n" \
  378.                                          % program)
  379.                         vs = supported_versions(opts.version_only)
  380.                 except ValueError, e:
  381.                     sys.stderr.write("%s: %s\n" % (program, e))
  382.                     sys.exit(4)
  383.             else:
  384.                 vs = requested_versions(versions, opts.version_only)
  385.             print ' '.join(vs)
  386.         except ValueError, msg:
  387.             sys.stderr.write("%s: %s\n" % (program, msg))
  388.             sys.exit(1)
  389.     else:
  390.         sys.stderr.write("usage: %s %s\n" % (program, usage))
  391.         sys.exit(1)
  392.  
  393. if __name__ == '__main__':
  394.     main()
  395.